package com.yupi.yuaicodemother.ai;


//import com.yupi.yuaicodemother.ai.tools.FileWriteTool;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.yupi.yuaicodemother.exception.BusinessException;
import com.yupi.yuaicodemother.exception.ErrorCode;
import com.yupi.yuaicodemother.model.enums.CodeGenTypeEnum;
import com.yupi.yuaicodemother.service.ChatHistoryService;
import dev.langchain4j.community.store.memory.chat.redis.RedisChatMemoryStore;
import dev.langchain4j.data.message.ToolExecutionResultMessage;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.chat.StreamingChatModel;
import dev.langchain4j.service.AiServices;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;

@Slf4j
@Configuration
public class AiCodeGeneratorServiceFactory {

    @Resource
    private ChatModel chatModel;

    @Resource
    private StreamingChatModel openAiStreamingChatModel;


    @Resource
    private StreamingChatModel reasoningStreamingChatModel;


    @Resource
    private ChatHistoryService chatHistoryService;




//    @Bean
//    public AiCodeGeneratorService aiCodeGeneratorService() {
//        return AiServices.builder(AiCodeGeneratorService.class)
//                .chatModel(chatModel)
//                .streamingChatModel(openAiStreamingChatModel)
//                .build();
//    }

    @Resource
    private  RedisChatMemoryStore redisChatMemoryStore;






    /**
     * AI 服务实例缓存
     * 缓存策略：
     * - 最大缓存 1000 个实例
     * - 写入后 30 分钟过期
     * - 访问后 10 分钟过期
     */
    private final Cache<Long, AiCodeGeneratorService> serviceCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(30))
            .expireAfterAccess(Duration.ofMinutes(10))
            .removalListener((key, value, cause) -> {
                log.debug("AI 服务实例被移除，appId: {}, 原因: {}", key, cause);

            })
            .build();

    /**
     * 根据 appId 获取服务（带缓存）
     */
    public AiCodeGeneratorService getAiCodeGeneratorService(long appId) {
        return serviceCache.get(appId, this::createAiCodeGeneratorService);
    }

    /**
     * 创建新的 AI 服务实例
 * 该方法用于根据应用ID创建一个独立的AI代码生成服务实例
 * 每个实例都有自己独立的对话记忆，确保上下文隔离
 *
 * @param appId 应用ID，用于标识不同的应用实例
 * @return 返回配置好的AI代码生成服务实例
     */
    private AiCodeGeneratorService createAiCodeGeneratorService(long appId) {
    // 记录创建服务实例的日志
        log.info("为 appId: {} 创建新的 AI 服务实例", appId);
        // 根据 appId 构建独立的对话记忆
    // 使用 MessageWindowChatMemory 来维护最近的对话历史
    // 设置最大消息数为20，以控制上下文长度
        MessageWindowChatMemory chatMemory = MessageWindowChatMemory
                .builder()
                .id(appId)                    // 设置记忆ID，确保每个实例独立
                .chatMemoryStore(redisChatMemoryStore)  // 使用Redis存储聊天记忆
                .maxMessages(20)             // 限制最大消息数量
                .build();
        //从数据库加载历史对话到记忆中
        chatHistoryService.loadChatHistoryToMemory(appId, chatMemory, 20);
    // 使用AiServices构建器创建AI服务实例
    // 配置聊天模型、流式聊天模型和对话记忆
        return AiServices.builder(AiCodeGeneratorService.class)
                .chatModel(chatModel)                    // 设置普通聊天模型
                .streamingChatModel(openAiStreamingChatModel)  // 设置流式聊天模型
                .chatMemory(chatMemory)                  // 设置对话记忆
                .build();
    }

//        /**
//         * 根据 appId 获取服务
//         */
//        public AiCodeGeneratorService getAiCodeGeneratorService(long appId) {
//            // 根据 appId 构建独立的对话记忆
//            MessageWindowChatMemory chatMemory = MessageWindowChatMemory
//                    .builder()
//                    .id(appId)
//                    .chatMemoryStore(redisChatMemoryStore)
//                    .maxMessages(20)
//                    .build();
//            return AiServices.builder(AiCodeGeneratorService.class)
//                    .chatModel(chatModel)
//                    .streamingChatModel(openAiStreamingChatModel)
//                    .chatMemory(chatMemory)
//                    .build();
//        }


    /**
     * 默认提供一个 Bean
     */
    @Bean
    public AiCodeGeneratorService aiCodeGeneratorService() {
        return getAiCodeGeneratorService(0L);
    }

//    //会话记忆1.0
//    @Bean
//    public AiCodeGeneratorService aiCodeGeneratorService() {
//    // 使用AiServices构建器创建AiCodeGeneratorService实例
//        return AiServices.builder(AiCodeGeneratorService.class)
//            // 设置聊天模型
//                .chatModel(chatModel)
//            // 设置流式聊天模型
//                .streamingChatModel(openAiStreamingChatModel)
//                // 根据 id 构建独立的对话记忆
//                .chatMemoryProvider(memoryId -> MessageWindowChatMemory
//                        .builder()
//                        .id(memoryId)  // 设置记忆ID
//                        .chatMemoryStore(redisChatMemoryStore)  // 使用Redis作为聊天记忆存储
//                        .maxMessages(20)  // 设置最大记忆消息数为20
//                        .build())
//            // 构建并返回AiCodeGeneratorService实例
//                .build();
//    }




}


